数目|动量_深度学习基础：4.Pytorch搭建基础网络模型

篇首语：本文由编程笔记#小编为大家整理，主要介绍了深度学习基础：4.Pytorch搭建基础网络模型相关的知识，希望对你有一定的参考价值。

这个专栏停更了一段时间&＃xff0c;现在重新开始&＃xff0c;巩固基础才能看懂复杂代码。

使用Pytorch之前&＃xff0c;首先要理清楚Pytorch基本架构。
Pytorch的核心库是torch&＃xff0c;根据不同领域细分可以分成计算机视觉、自然语言处理和语音处理&＃xff0c;这三个领域分别有自己对应的库&＃xff0c;即torchvision、torchtext、torchaudio。

核心库Torch中&＃xff0c;根据功能又可以细分成下面几个模块。

下面就用Pytorch搭建一个简单的正向传播结构。

首先导库&＃xff0c;这里需要三个库&＃xff0c;torch基本库不必说&＃xff0c;nn即neural network&＃xff0c;包含了神经网络结构的基本元素。functional 包含了损失函数和激活函数。

import torch
import torch.nn as nn
from torch.nn import functional as F


之后进行数据生成
这里manual_seed是固定人为的随机种子&＃xff0c;因为不固定该值&＃xff0c;每次运行时神经网络各层的初始权重/偏置会进行随机初始化&＃xff0c;导致结果不稳定。
X是生成(500,20)的数据&＃xff0c;注意必须指定其数据格式为浮点型(float32)&＃xff0c;否则默认为整型。
y是随机生成500条(0,3]之间的数&＃xff0c;注意y也是浮点型&＃xff0c;因为在后面损失函数计算时需要浮点型数据。

torch.random.manual_seed(103)
X &＃61; torch.rand((500,20), dtype&＃61;torch.float32)
y &＃61; torch.randint(low&＃61;0,high&＃61;3,size&＃61;(500,1), dtype&＃61;torch.float32)


接下来就到了最核心的搭建网络结构模块

• 1、定义模型类&＃xff0c;注意要继承于nn.Module
• 2、在初始化函数中继承父类的初始化函数 super(Model,self).__init__()&＃xff0c;这是由于python的继承机制不会继承父类的 __init__
• 3、指定输入输出神经元数目in_features和out_features&＃xff0c;这并不是必须的&＃xff0c;但是如果把输入输出作为参数进行传递&＃xff0c;会增强模型的通用性。
• 4、构造Linear线性层&＃xff0c;注意一个线性层输出和下一个线性层的输入个数需相等&＃xff0c;否则无法计算(原理上就是矩阵相乘)
• 5、构造forward函数&＃xff0c;实现前向传播过程&＃xff0c;指定每一层的输入输出和激活函数。

class Model(nn.Module):
def __init__(self,in_features&＃61;10, out_features&＃61;2):
"""
in_features: 输入该神经网络的特征数目&＃xff08;输入层上的神经元的数目&＃xff09;
out_features&＃xff1a;神经网络的输出的数目&＃xff08;输出层上的神经元的数目&＃xff09;
"""
super(Model,self).__init__()
self.linear1 &＃61; nn.Linear(in_features,13,bias&＃61;True)
self.linear2 &＃61; nn.Linear(13,8,bias&＃61;True)
self.output &＃61; nn.Linear(8,out_features,bias&＃61;True)

def forward(self,x): #神经网络的向前传播
z1 &＃61; self.linear1(x)
sigma1 &＃61; torch.relu(z1)
z2 &＃61; self.linear2(sigma1)
sigma2 &＃61; torch.sigmoid(z2)
z3 &＃61; self.output(sigma2)
sigma3 &＃61; F.softmax(z3,dim&＃61;1)
return sigma3


之后实例化网络&＃xff0c;注意在此之前要限定输入输出的个数&＃xff0c;这里选择输入即X的特征维度20&＃xff0c;输出y不同的数值(假设为分类问题&＃xff0c;输出不同的类别)

input_ &＃61; X.shape[1]
output_ &＃61; len(y.unique())
net &＃61; Model(in_features&＃61;input_, out_features &＃61; output_)


调用模型&＃xff0c;实现正向传播有下面两种书写方式&＃xff1a;

# 方式一
y_hat &＃61; net.forward(X)
# 方式二
y_hat &＃61; net(X)


两者的区别是方式一只会调用forward函数内容&＃xff0c;方式二回调用除 __init__之外的所有函数内容&＃xff0c;因此更推荐第一种写法。
这样执行之后&＃xff0c;输入向量维度为(500,20),输出结果为(500,3)&＃xff0c;即对每一条数据都根据20个特征得到了分类结果。

除此之外&＃xff0c;可以用下面的语句查看每一层的参数。比如&＃xff0c;查看linear1层的权重和偏置。

# 查看权重
net.linear1.weight
# 查看偏置
net.linear1.bias


使用net.linear1.weight.shape查看linear1层的维度&＃xff0c;输出为(13,20)&＃xff0c;然而linear1层的输入为20&＃xff0c;输出为13&＃xff0c;这是由于在公式计算中&＃xff0c;权重w会被转置再进行矩阵乘法运算。

有了正向传播结构之后&＃xff0c;就自然需要计算损失&＃xff0c;反向传播。在此之前&＃xff0c;有必要先了解一些损失函数的API。

回归损失函数

对于回归问题&＃xff0c;比较常见的损失函数是SSE和MSE&＃xff0c;两者的公式如下&＃xff1a;


在Pytoch中&＃xff0c;可以这样进行调用。

from torch.nn import MSELoss
# 生成随机数据
yhat &＃61; torch.randn(size&＃61;(50,),dtype&＃61;torch.float32)
y &＃61; torch.randn(size&＃61;(50,),dtype&＃61;torch.float32)
# SSE
criterion &＃61; MSELoss(reduction &＃61; "sum")
loss &＃61; criterion(yhat,y)
# MSE
criterion &＃61; MSELoss(reduction &＃61; "mean")
loss &＃61; criterion(yhat,y)


分类损失函数

对于分类问题&＃xff0c;最常采用的是交叉熵损失&＃xff0c;比如二分类交叉熵损失函数如下&＃xff1a;

Pytorch中&＃xff0c;BCELoss和BCEWithLogitsLoss均能实现此功能&＃xff0c;但后者的精度更高&＃xff0c;不过一般来说&＃xff0c;BCELoss基本够用。

from torch.nn import BCELoss, BCEWithLogitsLoss
# 生成随机数据
yhat &＃61; torch.randint(low&＃61;0,high&＃61;2,size&＃61;(10,1),dtype&＃61;torch.float32)
y &＃61; torch.randint(low&＃61;0,high&＃61;2,size&＃61;(10,1),dtype&＃61;torch.float32)
# 方式一
criterion &＃61; BCELoss()
loss &＃61; criterion(yhat,y)
# 方式二
criterion &＃61; BCEWithLogitsLoss()
loss &＃61; criterion(yhat,y)


MSELoss类似&＃xff0c;BCELoss也有sum、mean可选参数&＃xff0c;功能和前面类似。

对于多分类问题&＃xff0c;Pytorch提供了CrossEntropyLoss这个函数&＃xff0c;使用实例如下&＃xff1a;

from torch.nn import CrossEntropyLoss
# 生成随机数据
yhat &＃61; torch.randint(low&＃61;0,high&＃61;2,size&＃61;(10,2),dtype&＃61;torch.float32)
y &＃61; torch.randint(low&＃61;0,high&＃61;2,size&＃61;(10,),dtype&＃61;torch.float32)
# 多元交叉熵损失
criterion &＃61; CrossEntropyLoss()
loss &＃61; criterion(yhat, y.long())


使用注意&＃xff1a;1、yhat必须>&＃61;2维&＃xff0c;如果是1维数据会报错。2、CrossEntropyLoss计算时要求标签必须是整型数据&＃xff0c;因此用y.long()将浮点型转换成整型。

有了损失函数之后&＃xff0c;在Pytorch中就可以用一行命令实现反向传播&＃xff0c;即loss.backward()
把损失函数和反向传播添加到前向传播过程中&＃xff0c;就形成了一轮简单的神经网络训练过程。

import torch
import torch.nn as nn
from torch.nn import functional as F
#确定数据
torch.random.manual_seed(103)
X &＃61; torch.rand((500,20), dtype&＃61;torch.float32)
y &＃61; torch.randint(low&＃61;0,high&＃61;3,size&＃61;(500,1), dtype&＃61;torch.float32)
input_ &＃61; X.shape[1]
output_ &＃61; len(y.unique())
class Model(nn.Module):
def __init__(self,in_features&＃61;10, out_features&＃61;2):
"""
in_features: 输入该神经网络的特征数目&＃xff08;输入层上的神经元的数目&＃xff09;
out_features&＃xff1a;神经网络的输出的数目&＃xff08;输出层上的神经元的数目&＃xff09;
"""
super(Model,self).__init__()
self.linear1 &＃61; nn.Linear(in_features,13,bias&＃61;True)
self.linear2 &＃61; nn.Linear(13,8,bias&＃61;True)
self.output &＃61; nn.Linear(8,out_features,bias&＃61;True)

def forward(self,x): #神经网络的向前传播
z1 &＃61; self.linear1(x)
sigma1 &＃61; torch.relu(z1)
z2 &＃61; self.linear2(sigma1)
sigma2 &＃61; torch.sigmoid(z2)
z3 &＃61; self.output(sigma2)
sigma3 &＃61; F.softmax(z3,dim&＃61;1)
return sigma3

net &＃61; Model(in_features&＃61;input_, out_features &＃61; output_) # 实例化神经网络
y_hat &＃61; net.forward(X) # 向前传播
criterion &＃61; nn.CrossEntropyLoss()
loss &＃61; criterion(y_hat,y.reshape(500).long())
loss.backward()
# loss.backward(retain_graph&＃61;True)


注意&＃xff1a;Pytorch的反向传播底层是基于一个动态的计算图&＃xff0c;每次执行完backward之后&＃xff0c;这个计算图会从内存中自动销毁&＃xff0c;如果想要保留这张图&＃xff0c;以便进行多次反向传播&＃xff0c;可以设置参数retain_graph&＃61;True
上述模型计算图可视化如下&＃xff1a;

上面实现了一个最基本正向传播和反向传播的过程&＃xff0c;然而&＃xff0c;如果要应用更加复杂优化算法&＃xff0c;直接手写就非常麻烦。Pytorch提供了一个优化器(optim)&＃xff0c;其内部封装了大量优化算法&＃xff0c;可以方便开发者快速调用。

例如&＃xff0c;实现随机梯度下降&＃xff0c;可以调用optim的SGD接口&＃xff0c;调用接口如下&＃xff1a;

class torch.optim.SGD(params, lr&＃61;, momentum&＃61;0, dampening&＃61;0, weight_decay&＃61;0, nesterov&＃61;False)


相关参数解释&＃xff1a;

optim更多接口参数解释&＃xff0c;看到这篇博客记录比较详细&＃xff0c;放置链接如下&＃xff1a;
Link&＃xff1a;https://blog.csdn.net/xq151750111/article/details/123602946

下面还是以之前的网络模型为例&＃xff0c;实现一个带动量参数的SGD优化器

import torch
import torch.nn as nn
import torch.optim as optim
from torch.nn import functional as F
torch.manual_seed(103)
X &＃61; torch.rand((500,20),dtype&＃61;torch.float32) * 100
y &＃61; torch.randint(low&＃61;0,high&＃61;3,size&＃61;(500,),dtype&＃61;torch.float32)
lr &＃61; 0.1 # 学习率
gamma &＃61; 0.9 # 动量
class Model(nn.Module):
def __init__(self,in_features&＃61;10,out_features&＃61;2):
super(Model,self).__init__()
self.linear1 &＃61; nn.Linear(in_features,13,bias&＃61;True)
self.linear2 &＃61; nn.Linear(13,8,bias&＃61;True)
self.output &＃61; nn.Linear(8,out_features,bias&＃61;True)

def forward(self, x):
sigma1 &＃61; torch.relu(self.linear1(x))
sigma2 &＃61; torch.sigmoid(self.linear2(sigma1))
zhat &＃61; self.output(sigma2)
return zhat

input_ &＃61; X.shape[1] #特征的数目
output_ &＃61; len(y.unique()) #分类的数目
net &＃61; Model(in_features&＃61;input_, out_features&＃61;output_) #实例化网络
criterion &＃61; nn.CrossEntropyLoss() #定义损失函数
opt &＃61; optim.SGD(net.parameters(),lr &＃61; lr,momentum &＃61; gamma)
yhat &＃61; net.forward(X)
loss &＃61; criterion(yhat, y.long()) #计算损失函数
loss.backward()
opt.step() #走一步&＃xff0c;更新权重w&＃xff0c;更新动量v
opt.zero_grad() #清除原来储存好的&＃xff0c;基于上一个坐标点计算的梯度&＃xff0c;为下一次计算梯度腾出空间


这一段代码就是实现了梯度下降中的一步&＃xff0c;加上循环&＃xff0c;就形成了常见的深度学习过程。

在数据量少时&＃xff0c;上面的代码能够完成训练。然而&＃xff0c;当数据量变大时&＃xff0c;就比较依赖硬件性能。比如&＃xff0c;如果使用的CPU版本的Pytorch&＃xff0c;数据会被加载进内存&＃xff0c;如果内存无法容纳所有数据就会产生爆内存的问题&＃xff0c;严重点可能会导致死机。如果使用GPU版本的Pytorch&＃xff0c;数据可以选择加载进显存&＃xff0c;如果显存不够大&＃xff0c;会产生爆显存的Bug。

为了解决这个问题&＃xff0c;可以将大批量的数据进行切分&＃xff0c;每次只送一批数据到模型中进行训练&＃xff0c;这批数据的大小就叫batch_size。

Pytorch为了数据切分提供了两个工具&＃xff0c;TensorDataset和DataLoader。
之前输入模型的数据和标签是分开的&＃xff0c;但是在后面的数据加载器DataLoader中&＃xff0c;需要输入数据和标签的整体。python中的zip函数能够实现打包功能&＃xff0c;Pytorch的TensorDataset函数功能也类似。不过对于tensor数据而言&＃xff0c;pytorch提供的函数通常比python原生函数运算更快一些。

TensorDataset的使用示例如下&＃xff1a;

from torch.utils.data import TensorDataset
a &＃61; torch.randn(500,3,4,5) #四维数据 - 图像
b &＃61; torch.randn(500,1) #二维数据 - 标签
c &＃61; TensorDataset(a,b)


直接打印c&＃xff0c;不会输出具体的值&＃xff0c;可以用下面的方式进行查看&＃xff1a;

for x in c:
print(x)
break


输出c中的第一项如图所示&＃xff1a;

里面包含两个tensor&＃xff0c;第一个是数据&＃xff0c;第二个是标签。

有了tensor之后&＃xff0c;就可以直接将数据输入到DataLoader之中。DataLoader是处理训练前的数据加载器&＃xff0c;它可以接受任意形式的数组、张量作为输入&＃xff0c;并把他们一次性转换为神经网络可以接入的tensor。

DataLoader有很多参数&＃xff0c;这里使用三个&＃xff1a;

• batch_size
  指定每一批(batch)数据的大小
• shuffle
  是否对数据进行打乱
• drop_last
  是否将最后一批不满足batch_size大小的数据丢弃

from torch.utils.data import DataLoader
dataset &＃61; DataLoader(c
, batch_size &＃61; 120
, shuffle &＃61; True #随机打乱数据
, drop_last &＃61; True #是否舍弃最后一个batch
)


打印出每个TensorDataset大小查看&＃xff1a;

for i in dataset:
print(i[0].shape) # i[0]是数据&＃xff0c;i[1]是标签


如图所示&＃xff0c;500条数据&＃xff0c;每个batch_size为120并舍弃最后一个batch&＃xff0c;因此输出四个batch。

在实际使用中&＃xff0c;通常这样进行调用。

for batch_idx, (x,y) in enumerate(dataset):
yhat &＃61; net(x)
loss &＃61; criterion(yhat, y)
loss.backward()
opt.step()
opt.zero_grad()